{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 使用ModelScope ViT模型完成图像分类模型微调和部署\n",
    "\n",
    "## 背景介绍\n",
    "\n",
    "\n",
    "[ModelScope](https://www.modelscope.cn)是一个旨在为泛AI开发者提供灵活、易用、低成本的一站式“模型即服务”（MaaS）的开源平台。它汇集了丰富的预训练模型，覆盖了NLP、CV、Audio、AIGC、多模态大模型等多个领域。利用ModelScope所提供的模型以及ModelScope Library，开发者可以用一行代码实现模型推理，或者用十几行代码实现对预训练模型的调优训练，方便开发者基于行业数据集快速构建专属行业模型。\n",
    "\n",
    "当前示例中，我们以[ViT图像分类-通用](https://modelscope.cn/models/damo/cv_vit-base_image-classification_ImageNet-labels/summary) 为示例，展示如何在PAI完成一个ModelScope模型的微调训练，然后将获得的模型部署为一个在线推理服务的过程。主要流程包括：\n",
    "\n",
    "1. 准备工作：\n",
    "\n",
    "安装PAI Python SDK，并完成SDK配置。\n",
    "\n",
    "2. 模型的微调训练\n",
    "\n",
    "编写微调训练脚本，使用[花朵分类](https://www.modelscope.cn/models/zydfx1111/flower)数据集对模型进行微调训练，以获得一个可以用于花朵分类的模型。\n",
    "\n",
    "3. 部署推理服务\n",
    "\n",
    "将微调训练作业输出的模型，部署到PAI-EAS，创建一个在线推理服务。\n",
    "\n",
    "## 前提条件\n",
    "\n",
    "- 已获取阿里云账号的鉴权AccessKey ID和AccessKey Secret，详情请参见：[获取AccessKey](https://help.aliyun.com/document_detail/116401.html)。\n",
    "- 已创建或是加入一个PAI AI工作空间，详情请参见：[创建工作空间](https://help.aliyun.com/document_detail/326193.html)。\n",
    "- 已创建OSS Bucket，详情请参见：[控制台创建存储空间](https://help.aliyun.com/document_detail/31885.html)。\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step1: 准备工作\n",
    "\n",
    "我们将使用PAI提供的Python SDK，提交训练作业，部署模型。可以通过以下命令安装PAI Python SDK。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "skip-execution"
    ]
   },
   "outputs": [],
   "source": [
    "!python -m pip install --upgrade alipai"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "SDK需要配置访问阿里云服务需要的 AccessKey，以及当前使用的工作空间和OSS Bucket。在PAI Python SDK安装之后，通过在 **命令行终端** 中执行以下命令，按照引导配置密钥，工作空间等信息。\n",
    "\n",
    "\n",
    "```shell\n",
    "\n",
    "# 以下命令，请在 命令行终端 中执行.\n",
    "\n",
    "python -m pai.toolkit.config\n",
    "\n",
    "```\n",
    "\n",
    "我们可以通过以下代码验证当前的配置。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pai\n",
    "from pai.session import get_default_session\n",
    "\n",
    "print(pai.__version__)\n",
    "sess = get_default_session()\n",
    "\n",
    "assert sess.workspace_name is not None\n",
    "print(sess.workspace_name)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step2: 提交微调训练作业\n",
    "\n",
    "ModelScope的[ViT图片分类-通用](https://modelscope.cn/models/damo/cv_vit-base_image-classification_ImageNet-labels/summary)模型使用经典的[ViT Base](https://github.com/google-research/vision_transformer)模型结构，在ImageNet-1k数据集进行预训练，可以直接用于[ImageNet 1k标签](https://deeplearning.cms.waikato.ac.nz/user-guide/class-maps/IMAGENET/)覆盖图像的分类任务，也可以作为下游任务的预训练模型。\n",
    "\n",
    "当前示例，我们将以[花朵分类数据集](https://www.modelscope.cn/datasets/tany0699/flowers14/summary)对模型进行微调训练，从而获得一个可以用于花朵分类的模型。\n",
    "\n",
    "### 准备微调训练脚本\n",
    "\n",
    "ModelScope提供了功能完善的Python Library，能够支持用户方便得使用ModelScope模型进行推理以及微调训练，在本示例中，我们将使用ModelScope Library编写相应的微调训练脚本，然后提交到PAI执行微调训练作业。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "# 准备相应训练作业脚本目录\n",
    "!mkdir -p train_src"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "完整的微调训练脚本代码如下：\n",
    "\n",
    "> 对于ModelScope library的使用介绍，请参见：[ModelScope文档](https://www.modelscope.cn/docs/ModelScope%20Library%E6%A6%82%E8%A7%88%E4%BB%8B%E7%BB%8D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile train_src/finetune.py\n",
    "\n",
    "import os\n",
    "import re\n",
    "import logging\n",
    "import shutil\n",
    "\n",
    "\n",
    "from modelscope.msdatasets import MsDataset\n",
    "from modelscope.metainfo import Trainers\n",
    "from modelscope.trainers import build_trainer\n",
    "\n",
    "\n",
    "# 从环境变量中获取超参（由PAI的训练服务注入）\n",
    "BATCH_SIZE = int(os.environ.get(\"PAI_HPS_BATCH_SIZE\", 16))\n",
    "LEARNING_RATE = float(os.environ.get(\"PAI_HPS_INITIAL_LEARNING_RATE\", 1e-3))\n",
    "NUM_EPOCHS = int(os.environ.get(\"PAI_HPS_EPOCHS\", 1))\n",
    "NUM_CLASSES = int(os.environ.get(\"PAI_HPS_NUM_CLASSES\", 14))\n",
    "MODEL_ID_OR_PATH = os.environ.get(\"PAI_INPUT_MODEL\", \"damo/cv_vit-base_image-classification_ImageNet-labels\")\n",
    "\n",
    "# 通过环境变量获取输出模型，和checkpoints保存路径\n",
    "OUTPUT_MODEL_DIR = os.environ.get(\"PAI_OUTPUT_MODEL\", \"./model/\")\n",
    "WORK_DIR = os.environ.get(\"PAI_OUTPUT_CHECKPOINTS\", \"./checkpoints/\")\n",
    "\n",
    "\n",
    "# 将产出的模型保存到模型输出目录(OUTPUT_MODEL_DIR)\n",
    "def save_model():\n",
    "    best_ckpt_pattern = re.compile(\n",
    "        pattern=r\"^best_accuracy_top-1_epoch_\\d+.pth$\"\n",
    "    )\n",
    "    print(\"Saving best checkpoint as pytorch_model.pt\")\n",
    "    print(\"List work dir: \", os.listdir(WORK_DIR))\n",
    "\n",
    "    f_name = next((f for f in os.listdir(WORK_DIR) if best_ckpt_pattern.match(f)), None)\n",
    "    if f_name:\n",
    "        # 使用最佳checkpoints作为输出模型\n",
    "        print(\"Found best checkpoint: \", f_name)\n",
    "        shutil.copyfile(\n",
    "            src=os.path.join(WORK_DIR, f_name),\n",
    "            dst=os.path.join(OUTPUT_MODEL_DIR, \"pytorch_model.pt\"),\n",
    "        )\n",
    "        os.remove(os.path.join(WORK_DIR, f_name))\n",
    "    else:\n",
    "        # 如果没有，则使用最后一个epoch的checkpoints作为输出模型\n",
    "        print(\"Not found best checkpoint.\")\n",
    "        last_ckpt_file = \"epoch_{}.pth\".format(NUM_EPOCHS)\n",
    "        if os.path.isfile(os.path.join(WORK_DIR, last_ckpt_file)):\n",
    "            shutil.copyfile(\n",
    "                src=os.path.join(WORK_DIR, last_ckpt_file),\n",
    "                dst=os.path.join(OUTPUT_MODEL_DIR, \"pytorch_model.pt\"),\n",
    "            )\n",
    "        else:\n",
    "            print(\"Not found latest checkpoint: {}.\".format(os.path.join(WORK_DIR, last_ckpt_file)))\n",
    "    # 模型配置信息\n",
    "    shutil.copyfile(\n",
    "        src=os.path.join(WORK_DIR, \"configuration.json\"),\n",
    "        dst=os.path.join(OUTPUT_MODEL_DIR, \"configuration.json\"),\n",
    "    )\n",
    "\n",
    "\n",
    "# 修改配置文件\n",
    "def cfg_modify_fn(cfg):\n",
    "    cfg.train.dataloader.batch_size_per_gpu = BATCH_SIZE # batch大小\n",
    "    cfg.train.dataloader.workers_per_gpu = 8     # 每个gpu的worker数目\n",
    "    cfg.train.max_epochs = NUM_EPOCHS                     # 最大训练epoch数\n",
    "    cfg.model.mm_model.head.num_classes = NUM_CLASSES                       # 分类数\n",
    "    cfg.model.mm_model.train_cfg.augments[0].num_classes = NUM_CLASSES      # 分类数\n",
    "    cfg.model.mm_model.train_cfg.augments[1].num_classes = NUM_CLASSES      # 分类数\n",
    "    cfg.train.optimizer.lr = LEARNING_RATE                # 学习率\n",
    "    cfg.train.lr_config.warmup_iters = 1         # 预热次数\n",
    "\n",
    "    # Note: OSS挂载到输出路径中，不支持软链接.\n",
    "    cfg.train.checkpoint_config.create_symlink = False\n",
    "\n",
    "\n",
    "    return cfg\n",
    "\n",
    "def train():\n",
    "    ms_train_dataset = MsDataset.load(\n",
    "                'flowers14', namespace='tany0699',\n",
    "                subset_name='default', split='train') # 加载训练集\n",
    "\n",
    "    ms_val_dataset = MsDataset.load(\n",
    "                'flowers14', namespace='tany0699',\n",
    "                subset_name='default', split='validation') # 加载验证集\n",
    "\n",
    "\n",
    "    # 构建训练器\n",
    "    kwargs = dict(\n",
    "        model=MODEL_ID_OR_PATH,                 # 模型id\n",
    "        work_dir=WORK_DIR,\n",
    "        train_dataset=ms_train_dataset, # 训练集  \n",
    "        eval_dataset=ms_val_dataset,    # 验证集\n",
    "        cfg_modify_fn=cfg_modify_fn     # 用于修改训练配置文件的回调函数\n",
    "    )\n",
    "    trainer = build_trainer(name=Trainers.image_classification, default_args=kwargs)\n",
    "\n",
    "    # 进行训练\n",
    "    trainer.train()\n",
    "\n",
    "    # 进行评估\n",
    "    result = trainer.evaluate()\n",
    "    print('Evaluation Result:', result)\n",
    "\n",
    "    # 保存模型\n",
    "    save_model()\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    train()\n",
    "    "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在当前的训练作业中，我们将使用PAI提供的PyTorch训练镜像，需要在镜像中安装ModelScope Library。通过在训练作业脚本目录下准备一个`requirements.txt`文件，可以在训练作业启动时，自动安装依赖的第三方库。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile train_src/requirements.txt\n",
    "\n",
    "\n",
    "# 部分ModelScope依赖library由ModelScope Host，需要显式配置以下参数\n",
    "--find-links https://modelscope.oss-cn-beijing.aliyuncs.com/releases/repo.html\n",
    "modelscope[cv]==1.3.1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "完整的训练作业脚本目录结构如下：\n",
    "\n",
    "```shell\n",
    "\n",
    "train_src\n",
    "    ├── finetune.py\n",
    "    └── requirements.txt\n",
    "\n",
    "```\n",
    "\n",
    "后续我们将通过PAI Python SDK将训练脚本提交到PAI执行。\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 提交训练作业到PAI\n",
    "\n",
    "SDK提供了High-Level的API，`pai.estimator.Estimator`，支持用户方便地使用镜像配合训练脚本，提交训练作业到PAI。以下代码中，我们将使用以上的训练作业脚本（`train_src`目录），配合PAI提供的PyTorch训练镜像，提交一个训练作业。\n",
    "\n",
    "对于如何使用SDK提交训练作业的详细介绍，可以见文档：[提交训练作业](https://help.aliyun.com/document_detail/2261505.html)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pai.estimator import Estimator\n",
    "from pai.image import retrieve\n",
    "\n",
    "\n",
    "# 使用PAI提供的最新的PyTorch GPU镜像\n",
    "torch_img_uri = retrieve(\n",
    "    \"PyTorch\",\n",
    "    \"latest\",\n",
    "    accelerator_type=\"gpu\",\n",
    ").image_uri\n",
    "\n",
    "# 使用训练配置信息，创建Estimator对象\n",
    "est = Estimator(\n",
    "    command=\"python finetune.py\",  # 训练作业的启动命令\n",
    "    source_dir=\"train_src\",  # 训练作业脚本本地目录（绝对路径，或是相对路径）\n",
    "    image_uri=torch_img_uri,  # 作业的镜像类型\n",
    "    # instance_type=\"ecs.gn6e-c12g1.3xlarge\",   # 12vCPU 92GiB NVIDIA V100 × 1 (32GB GPU memory)\n",
    "    instance_type=\"ecs.gn7i-c8g1.2xlarge\",  # 8vCPU 30GiB NVIDIA A10 × 1 (24GB GPU Memory)\n",
    "    base_job_name=\"vit-finetune\",  # 作业名称\n",
    "    hyperparameters={  # 训练作业超参，用户可以通过环境变量或是读取配置文件的方式获取.\n",
    "        \"batch_size\": 128,\n",
    "        \"initial_learning_rate\": 1e-4,\n",
    "        \"epochs\": 2,\n",
    "        # 花朵数据集一共14个分类\n",
    "        \"num_classes\": 14,\n",
    "    },\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过`fit` API提交训练作业。当前示例中，我们在训练脚本中使用ModelScope的library去下载数据集。当用户需要使用自定义数据集时，可以通过`fit`方法传递相应数据OSS路径，训练作业会通过挂载的方式将相应的数据准备的执行环境中。\n",
    "\n",
    "```python\n",
    "\n",
    "est.fit(\n",
    "\t# 用户的训练作业脚本可以通过环境变量 PAI_INPUT_{ChannelNameUpperCase} 获得数据的本地路径.\n",
    "\t\"train\": \"oss://<your-bucket>/train/data/path/\",\n",
    ")\n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "est.fit()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练作业执行成功之后，用户可以通过`estimator.model_data()`获取相应产出模型的OSS路径"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step3: 部署推理服务\n",
    "\n",
    "PAI-EAS是PAI提供的推理服务部署平台，支持使用Processor或是镜像的方式部署推理服务。在以下的流程中，我们将使用微调获得的模型，使用镜像部署的方式部署一个在线推理服务。\n",
    "\n",
    "### 准备推理服务使用的代码\n",
    "\n",
    "镜像部署的模式，要求用户提供一个推理服务程序，他负责加载模型，提供HTTP API，以支持接受用户推理请求，调用模型处理推理请求，返回推理结果。在当前示例中，我们将使用[FastAPI](https://fastapi.tiangolo.com/)编写一个推理服务程序，加载以上训练作业输出的模型，在PAI创建一个推理服务。\n",
    "\n",
    "我们首先创建一个目录(`serve_src`)，用于保存的推理服务程序代码。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!mkdir -p serve_src/"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们准备的推理服务程序，支持用户通过HTTP POST发送的图片，然后调用ModelScope的推理pipeline获取预测结果，返回给到用户。\n",
    "\n",
    "> ModelScope 推理pipeline返回的结果中带有`numpy.ndarray`数据，需要我们通过自定义Encoder将其序列化。\n",
    "\n",
    "完整代码如下，我们将其保存到`serve_src`目录下，用于后续创建推理服务。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile serve_src/run.py\n",
    "\n",
    "import os\n",
    "import io\n",
    "import json\n",
    "\n",
    "import uvicorn\n",
    "from fastapi import FastAPI, Response, Request\n",
    "import numpy as np\n",
    "\n",
    "from modelscope.pipelines import pipeline\n",
    "from modelscope.utils.constant import Tasks\n",
    "from PIL import Image\n",
    "\n",
    "# 用户指定模型，默认会被加载到当前路径下。 \n",
    "MODEL_PATH = \"/eas/workspace/model/\"\n",
    "\n",
    "class NumpyEncoder(json.JSONEncoder):\n",
    "\n",
    "    def default(self, obj):\n",
    "        if isinstance(obj, np.ndarray):\n",
    "            return obj.tolist()\n",
    "        elif isinstance(obj, np.generic):\n",
    "            return obj.item()\n",
    "        else:\n",
    "            return json.JSONEncoder.default(self, obj)\n",
    "\n",
    "app = FastAPI()\n",
    "\n",
    "@app.post(\"/\")\n",
    "async def predict(request: Request):\n",
    "    global p\n",
    "    content = await request.body()\n",
    "    img = Image.open(io.BytesIO(content))\n",
    "    res = p(img)\n",
    "    return Response(content=json.dumps(res, cls=NumpyEncoder), media_type=\"application/json\")\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    p = pipeline(\n",
    "        Tasks.image_classification,\n",
    "        model=MODEL_PATH,\n",
    "    )\n",
    "    uvicorn.run(app, host='0.0.0.0', port=8000)\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建推理服务\n",
    "\n",
    "我们将使用PAI提供的ModelScope推理镜像，使用以上的推理服务程序，创建一个推理服务。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pai.model import container_serving_spec\n",
    "from pai.session import get_default_session\n",
    "from pai.model import Model\n",
    "from random import randint\n",
    "\n",
    "\n",
    "# 使用PAI QuickStart提供的ModelScope的镜像创建推理服务\n",
    "image_uri = (\n",
    "    \"registry.{}.aliyuncs.com/paiflow-public/quickstart:modelscope-1.2.0\".format(\n",
    "        get_default_session().region_id,\n",
    "    )\n",
    ")\n",
    "\n",
    "\n",
    "# 创建一个Model对象，他可以用于创建推理服务\n",
    "m: Model = Model(\n",
    "    # 使用以上训练作业产出的模型\n",
    "    model_data=est.model_data(),\n",
    "    # 配置模型的推理配置，包括使用的镜像，使用的推理服务脚本，推理的依赖包等。\n",
    "    inference_spec=container_serving_spec(\n",
    "        source_dir=\"./serve_src/\",\n",
    "        command=\"python run.py\",\n",
    "        image_uri=image_uri,\n",
    "        requirements=[\n",
    "            \"fastapi\",\n",
    "            \"uvicorn\",\n",
    "        ],\n",
    "    ),\n",
    ")\n",
    "\n",
    "\n",
    "print(m.inference_spec.to_dict())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "指定推理服务的名称，以及使用的机器实例规格，创建一个推理服务。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pai.predictor import Predictor\n",
    "\n",
    "\n",
    "p: Predictor = m.deploy(\n",
    "    service_name=\"modelscope_vit_{}\".format(randint(0, 100000)),\n",
    "    instance_type=\"ecs.c6.xlarge\",\n",
    "    options={\n",
    "        # 推理镜像较大的镜像下，需要配置额外的磁盘空间\n",
    "        \"features.eas.aliyun.com/extra-ephemeral-storage\": \"40GB\"\n",
    "    },\n",
    ")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`model.deploy` 返回的`Predictor`对象可以用于向相应的推理服务发送请求，获得推理结果。\n",
    "\n",
    "\n",
    "这里我们使用已经准备的一张花朵图片测试推理服务。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": [
     "keep_output"
    ]
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=256x256 at 0x7FC9DA00F1C0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import io\n",
    "\n",
    "import requests\n",
    "from PIL import Image\n",
    "from IPython import display\n",
    "\n",
    "url = \"https://pai-sdk.oss-cn-shanghai.aliyuncs.com/resources/images/11563567033_b822736d84_c.jpeg\"\n",
    "\n",
    "data = requests.get(url).content\n",
    "\n",
    "display.display(Image.open(io.BytesIO(data)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pai.predictor import RawResponse\n",
    "\n",
    "resp: RawResponse = p.raw_predict(data=data)\n",
    "\n",
    "print(resp.json())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "在测试完成之后，我们可以将创建的服务删除。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p.delete_service()"
   ]
  }
 ],
 "metadata": {
  "execution": {
   "timeout": 1800
  },
  "kernelspec": {
   "display_name": "pai-dev-py38",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
